home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / p4 / p4-1_2a.lha / p4-1.2a / monitors / gridlog.shmem.c < prev    next >
C/C++ Source or Header  |  1992-10-19  |  7KB  |  301 lines
  1. #define ALOG_TRACE
  2. #include "p4.h"
  3. #include  <sys/tmp_ctl.h>
  4.  
  5. #define ASKFOR_WORK     1
  6. #define ASKED           2       
  7. #define START_WORK      3
  8. #define END_WORK        4
  9. #define PUTTING_IN_POOL 5
  10. #define PUT_IN_POOL     6
  11.  
  12. #define ROWS         200
  13. #define COLUMNS     200
  14. struct globmem {
  15.     double a[ROWS+2][COLUMNS+2];
  16.     double b[ROWS+2][COLUMNS+2];
  17.     int st[ROWS+2], pq[ROWS+1];
  18.     int pqbeg, pqend, goal, nproc, rows, columns;
  19.     p4_askfor_monitor_t MO;
  20.     p4_barrier_monitor_t BA;
  21. } *glob;
  22.  
  23. double avggrid();
  24. double avgbnd();
  25.  
  26. slave()
  27. {
  28.     ALOG_SETUP(p4_get_my_id(),ALOG_TRUNCATE);
  29.     work('s');
  30.     ALOG_OUTPUT;
  31. }
  32.  
  33. phi(x,y)            /* The function on the boundary */
  34. int x,y;
  35. {
  36.       return((x * x) - (y * y) + (x * y));   
  37. }
  38.  
  39. main(argc,argv)
  40. int argc;
  41. char **argv;
  42. {
  43.     int i;
  44.     int timestart, timeend;
  45.     double avg;
  46.  
  47.     p4_initenv(&argc,argv);
  48.  
  49.     ALOG_ENABLE;
  50.     ALOG_MASTER(p4_get_my_id(),ALOG_TRUNCATE);
  51.  
  52.     ALOG_DEFINE(ASKFOR_WORK,"Asking","");
  53.     ALOG_DEFINE(ASKED,"Asked","");
  54.     ALOG_DEFINE(START_WORK,"Working","slab %d");
  55.     ALOG_DEFINE(END_WORK,"Finished","slab %d");
  56.     ALOG_DEFINE(PUTTING_IN_POOL,"Putting","slab %d");
  57.     ALOG_DEFINE(PUT_IN_POOL,"Put","slab %d");
  58.  
  59.     glob = (struct globmem *) p4_shmalloc(sizeof(struct globmem));
  60.  
  61.     p4_askfor_init(&(glob->MO));
  62.     p4_barrier_init(&(glob->BA));
  63.  
  64. /*
  65.     printf("enter number of processes: ");
  66.     scanf("%d",&glob->nproc);
  67. */
  68.     printf("enter the number of rows: ");
  69.     scanf("%d",&glob->rows);
  70.     printf("enter the number of columns: ");
  71.     scanf("%d",&glob->columns);
  72.     printf("enter the number of iterations: ");
  73.     scanf("%d",&glob->goal);
  74.  
  75.     gridinit(glob->a,glob->rows,glob->columns);
  76.     gridinit(glob->b,glob->rows,glob->columns);
  77.     
  78.     glob->pqbeg = glob->pqend = 0;
  79.     for (i=1; i <= glob->rows; i++)
  80.         queueprob(i);
  81.  
  82.     /* initialize the status vector */
  83.     for (i=0; i < (glob->rows+2); i++)
  84.         glob->st[i] = 0;
  85.  
  86.     p4_create_procgroup();
  87.     glob->nproc = p4_num_total_ids();
  88.  
  89.     printf("\nnproc\tgoal\trows\tcolumns\n");
  90.     printf("%d \t  %d \t  %d \t  %d \n",
  91.        glob->nproc,glob->goal,glob->rows,glob->columns);
  92.     timestart = p4_clock();
  93. /*
  94.     for (i=1; i <= glob->nproc-1; i++) {
  95.         p4_create(slave);
  96.     }
  97. */
  98.     work('m');
  99.     timeend = p4_clock();
  100.     printf("total time %.3f seconds\n",(timeend - timestart)/1000.0);
  101.  
  102. /* 
  103.     printf("the resulting grid:\n");
  104.     if (glob->goal % 2 == 0)
  105.         printgrid(glob->a,glob->rows,glob->columns);
  106.     else
  107.         printgrid(glob->b,glob->rows,glob->columns);
  108. */
  109.     if (glob->goal % 2 == 0)
  110.         avg = avggrid(glob->a,glob->rows,glob->columns);
  111.     else
  112.         avg = avggrid(glob->b,glob->rows,glob->columns);
  113.     printf("average value of grid = %f\n",avg);
  114.  
  115.     ALOG_OUTPUT;
  116.     p4_wait_for_end(); 
  117. }
  118.  
  119. /* "m" is the matrix, "r" is the number of rows of data (m[1]-m[r];
  120.    m[0] and m[r+1] are boundaries), and "c" is the number of columns
  121.    of data.
  122. */
  123.  
  124. gridinit(m,r,c)
  125. double m[ROWS+2][COLUMNS+2];
  126. int r, c;
  127. {
  128.     int i, j;
  129.     double bndavg;
  130.     
  131.     for (j=0; j < (c + 2); j++)
  132.     {
  133.         m[0][j] = phi(1,j+1);
  134.         m[r+1][j]= phi(r+2,j+1);
  135.     }
  136.     for (i=1; i < (r + 2); i++)
  137.     {
  138.         m[i][0] = phi(i+1,1);
  139.         m[i][c+1] = phi(i+1,c+2);
  140.     }
  141.     bndavg = avgbnd(m,r,c);
  142.     printf("boundary average = %f\n",bndavg);
  143.  
  144.     /* initialize the interior of the grids to the average over the boundary*/
  145.     for (i=1; i <= r; i++)
  146.         for (j=1; j <= c; j++)
  147.             /* m[i][j] = bndavg; this optimization hinders debugging */
  148.         m[i][j] = 0;
  149. }
  150.  
  151. queueprob(x)
  152. int x;
  153. {
  154.     glob->pq[glob->pqend] = x;
  155.     glob->pqend = (glob->pqend + 1) % (ROWS + 1);
  156. }
  157.  
  158. compute(p,q,r,columns)
  159. double p[ROWS+2][COLUMNS+2];
  160. double q[ROWS+2][COLUMNS+2];
  161. int r;
  162. int columns;
  163. {
  164.     int j;
  165.  
  166.     for (j = 1; j <= columns; j++) 
  167.         q[r][j] = (p[r-1][j] + p[r+1][j] + p[r][j-1] + p[r][j+1]) / 4.0;
  168. }
  169.  
  170. int putprob(r)
  171. int r;
  172. {
  173.     int qprob;
  174.  
  175.     ALOG_LOG(p4_get_my_id(),PUTTING_IN_POOL,r,"");
  176.  
  177.     qprob = FALSE;
  178.     glob->st[r]++;
  179.     if (r == 1)
  180.         glob->st[0] = glob->st[r];
  181.  
  182.     else if (r == glob->rows)
  183.         glob->st[glob->rows+1] = glob->st[r];
  184.  
  185.     if (glob->st[r] < glob->goal)
  186.     {
  187.         if ((r > 1) && (glob->st[r-2] >= glob->st[r]) 
  188.             && (glob->st[r-1] == glob->st[r]))
  189.     {
  190.             queueprob(r-1);
  191.             qprob = TRUE;
  192.         }
  193.         if (r < glob->rows && glob->st[r+1] == glob->st[r] 
  194.                && glob->st[r+1] <= glob->st[r+2])
  195.     {
  196.             queueprob(r+1);
  197.             qprob = TRUE;
  198.         }
  199.         if (glob->st[r-1] == glob->st[r] && 
  200.         glob->st[r] == glob->st[r+1])
  201.     {
  202.             queueprob(r);
  203.             qprob = TRUE;
  204.         }
  205.     }
  206.     ALOG_LOG(p4_get_my_id(),PUT_IN_POOL,qprob,"");
  207.     return(qprob);
  208. }
  209.  
  210. int getprob(v)
  211. int *v;
  212. {
  213.     int rc = 1;
  214.     int *p = (int *) v;
  215.  
  216.     if (glob->pqbeg != glob->pqend) 
  217.     {
  218.     *p = glob->pq[glob->pqbeg];
  219.     glob->pqbeg = (glob->pqbeg+1) % (ROWS + 1); 
  220.     rc = 0;
  221.     }
  222.     return(rc);
  223. }
  224.  
  225. P4VOID reset() 
  226. {
  227. }
  228.  
  229. work(who)            /* main routine for all processes */
  230. char who;
  231. {
  232.     int r,rc,i;
  233.     int my_id = p4_get_my_id();
  234.  
  235.     printf("old tmp_affinity = %d\n",tmp_affinity(my_id));
  236.     printf("new tmp_affinity = %d\n",tmp_affinity(AFF_QUERY));
  237.  
  238.     p4_barrier(&(glob->BA),glob->nproc);
  239.  
  240.     ALOG_LOG(my_id, ASKFOR_WORK, 0, "");
  241.     rc = p4_askfor(&(glob->MO),glob->nproc,getprob,(P4VOID *)&r,reset);
  242.     ALOG_LOG(my_id,ASKED,rc,"");
  243.  
  244.     while (rc == 0) {
  245.     ALOG_LOG(my_id,START_WORK,r,"");
  246.     if ((glob->st[r] % 2) == 0)
  247.         compute(glob->a,glob->b,r,glob->columns);
  248.     else 
  249.         compute(glob->b,glob->a,r,glob->columns);
  250.     ALOG_LOG(my_id,END_WORK,r,"");
  251.  
  252.     p4_update(&(glob->MO),putprob,(P4VOID *) r);
  253.  
  254.     ALOG_LOG(my_id, ASKFOR_WORK, 0, "");
  255.     rc = p4_askfor(&(glob->MO),glob->nproc,getprob,(P4VOID *)&r,reset);
  256.     ALOG_LOG(my_id,ASKED,rc,"");
  257.     }
  258. }
  259.  
  260. printgrid(m,r,c)
  261. double m[ROWS+2][COLUMNS+2];
  262. int r,c;
  263. {
  264.     int i,j;
  265.     for (i = 0; i < (r+2); i++)
  266.     for (j = 0; j < (c+2); j++)
  267.         printf("%3d %3d %10.5f\n",i,j,m[i][j]);
  268. }
  269.  
  270. double avggrid(m,r,c)
  271. double m[ROWS+2][COLUMNS+2];
  272. int r,c;
  273. {
  274.     int i,j;
  275.     double avg = 0;
  276.  
  277.     for (i = 0; i < (r+2); i++)
  278.     for (j = 0; j < (c+2); j++)
  279.         avg += m[i][j];
  280.     return(avg/((r+2)*(c+2)));
  281. }
  282.  
  283. double avgbnd(m,r,c)
  284. double m[ROWS+2][COLUMNS+2];
  285. int r,c;
  286. {
  287.     int i,j;
  288.     double avg = 0;
  289.  
  290.     for (i = 0; i < (r+2); i++)
  291.         avg += m[i][0];
  292.     for (i = 0; i < (r+2); i++)
  293.         avg += m[i][c+1];
  294.     for (i = 1; i < (c+1); i++)
  295.         avg += m[0][i];
  296.     for (i = 1; i < (c+1); i++)
  297.         avg += m[r+1][i];
  298.     return(avg/(2*(c+2) + 2*(r+2) - 4)); /* average over boundary */
  299. }
  300.  
  301.